---

QSVM Application

Objective: Example of the QSVM application

• Bagged bootstrapping of QSVM

---

# Import numpy
import numpy as np
import pandas as pd

# Import basic object from the Qiskit
from qiskit import QuantumCircuit
from qiskit import Aer,BasicAer
from qiskit import execute

# We will need these two
from qiskit.utils import QuantumInstance
from qiskit_machine_learning.kernels import QuantumKernel

# Load account from the disk
from qiskit import IBMQ
IBMQ.load_account() 

# We will need this for plots
from qiskit.visualization import plot_histogram,plot_bloch_multivector

ibmqfactory.load_account:WARNING:2022-03-13 17:57:22,860: Credentials are already in use. The existing account in the session will be replaced.

# Check the version of the qiskit you use

# Compared to previous class, I have installed the up-to-date version
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.19.2
qiskit-aer	0.10.3
qiskit-ignis	0.7.0
qiskit-ibmq-provider	0.18.3
qiskit	0.34.2
qiskit-machine-learning	0.3.1
System information
Python version	3.8.12
Python compiler	Clang 10.0.0
Python build	default, Oct 12 2021 06:23:56
OS	Darwin
CPUs	4
Memory (Gb)	8.0
Sun Mar 13 17:50:17 2022 GMT

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

# Ideal simulator
simulator = Aer.get_backend('qasm_simulator')

# Real-like simulator
from qiskit.providers.aer.noise import NoiseModel

# Choose a particuler quantum computer 
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_belem')

# We derive the noise model from the chosen quantum computer
noise_model = NoiseModel.from_backend(backend)

# Further, we assume the specific qauntum computer:
# Get coupling map from backend
coupling_map = backend.configuration().coupling_map

# Get basis gates from noise model
basis_gates = noise_model.basis_gates

# define backend (simulator with specific noise)
backendSimWithNoise = QuantumInstance(
    Aer.get_backend("qasm_simulator"), 
    coupling_map=coupling_map,
                 basis_gates=basis_gates,
                 noise_model=noise_model,
                shots=1024
)

ibmqfactory.load_account:WARNING:2022-03-13 17:51:24,385: Credentials are already in use. The existing account in the session will be replaced.

from sklearn import datasets

data = datasets.load_breast_cancer()

---

This is a good classification dataset in the sklearn library.

---

# dataframe
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target

import seaborn as sns
%matplotlib inline
sns.pairplot(df)

<seaborn.axisgrid.PairGrid at 0x7f9138ad8040>

df.head()

	mean radius	mean texture	mean perimeter	mean area	mean smoothness	mean compactness	mean concavity	mean concave points	mean symmetry	mean fractal dimension	...	worst texture	worst perimeter	worst area	worst smoothness	worst compactness	worst concavity	worst concave points	worst symmetry	worst fractal dimension	target
0	17.99	10.38	122.80	1001.0	0.11840	0.27760	0.3001	0.14710	0.2419	0.07871	...	17.33	184.60	2019.0	0.1622	0.6656	0.7119	0.2654	0.4601	0.11890	0
1	20.57	17.77	132.90	1326.0	0.08474	0.07864	0.0869	0.07017	0.1812	0.05667	...	23.41	158.80	1956.0	0.1238	0.1866	0.2416	0.1860	0.2750	0.08902	0
2	19.69	21.25	130.00	1203.0	0.10960	0.15990	0.1974	0.12790	0.2069	0.05999	...	25.53	152.50	1709.0	0.1444	0.4245	0.4504	0.2430	0.3613	0.08758	0
3	11.42	20.38	77.58	386.1	0.14250	0.28390	0.2414	0.10520	0.2597	0.09744	...	26.50	98.87	567.7	0.2098	0.8663	0.6869	0.2575	0.6638	0.17300	0
4	20.29	14.34	135.10	1297.0	0.10030	0.13280	0.1980	0.10430	0.1809	0.05883	...	16.67	152.20	1575.0	0.1374	0.2050	0.4000	0.1625	0.2364	0.07678	0

5 rows × 31 columns

df.describe()

	mean radius	mean texture	mean perimeter	mean area	mean smoothness	mean compactness	mean concavity	mean concave points	mean symmetry	mean fractal dimension	...	worst texture	worst perimeter	worst area	worst smoothness	worst compactness	worst concavity	worst concave points	worst symmetry	worst fractal dimension	target
count	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	...	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000	569.000000
mean	14.127292	19.289649	91.969033	654.889104	0.096360	0.104341	0.088799	0.048919	0.181162	0.062798	...	25.677223	107.261213	880.583128	0.132369	0.254265	0.272188	0.114606	0.290076	0.083946	0.627417
std	3.524049	4.301036	24.298981	351.914129	0.014064	0.052813	0.079720	0.038803	0.027414	0.007060	...	6.146258	33.602542	569.356993	0.022832	0.157336	0.208624	0.065732	0.061867	0.018061	0.483918
min	6.981000	9.710000	43.790000	143.500000	0.052630	0.019380	0.000000	0.000000	0.106000	0.049960	...	12.020000	50.410000	185.200000	0.071170	0.027290	0.000000	0.000000	0.156500	0.055040	0.000000
25%	11.700000	16.170000	75.170000	420.300000	0.086370	0.064920	0.029560	0.020310	0.161900	0.057700	...	21.080000	84.110000	515.300000	0.116600	0.147200	0.114500	0.064930	0.250400	0.071460	0.000000
50%	13.370000	18.840000	86.240000	551.100000	0.095870	0.092630	0.061540	0.033500	0.179200	0.061540	...	25.410000	97.660000	686.500000	0.131300	0.211900	0.226700	0.099930	0.282200	0.080040	1.000000
75%	15.780000	21.800000	104.100000	782.700000	0.105300	0.130400	0.130700	0.074000	0.195700	0.066120	...	29.720000	125.400000	1084.000000	0.146000	0.339100	0.382900	0.161400	0.317900	0.092080	1.000000
max	28.110000	39.280000	188.500000	2501.000000	0.163400	0.345400	0.426800	0.201200	0.304000	0.097440	...	49.540000	251.200000	4254.000000	0.222600	1.058000	1.252000	0.291000	0.663800	0.207500	1.000000

8 rows × 31 columns

# Create two data arrays
X = data.data
y = data.target

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

---

... however, we will not use this dataset directly, we will transform data into an informative subset using PCA.

---

# Use PCA to create three most informative features
from sklearn.decomposition import PCA

# We aim for three features
nFeatures = 3

pca = PCA(n_components=nFeatures)
pca.fit(X)

print(pca.explained_variance_ratio_)

[0.98204467 0.01617649 0.00155751]

# Define a transformed X
X = pca.fit_transform(X)

# Check the dimension
X.shape

(569, 3)

featureNames = ['f0','f1','f2']
df1 = pd.DataFrame(X,columns=featureNames)
df1['label'] = y

sns.pairplot(df1)

<seaborn.axisgrid.PairGrid at 0x7f9107ecc4c0>

# Split the sample
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

---

SVM vs QSVM

We will run SVM and QSV side by side.

SVM

---

# SVM
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

# Create a pipeline with standardisation
pipelineSVM = make_pipeline(StandardScaler(), SVC())

pipelineSVM.fit(X_train, y_train)

Pipeline(steps=[('standardscaler', StandardScaler()), ('svc', SVC())])

# Predict
y_predictSVM = pipelineSVM.predict(X_test)

from sklearn.metrics import accuracy_score
accuracy_score(y_test,y_predictSVM)

0.935672514619883

---

Model is fast and accurate!

QSVM

---

# Define Feature map, Pauli-Z evolution circuit 
from qiskit.circuit.library import ZZFeatureMap

# dimension of problem (number of qubits)
nQubits = X.shape[1]
# number of repetitions
nReps = 1

featureMap = ZZFeatureMap(feature_dimension=nQubits, reps=nReps, entanglement="full")

# define backend (simulator)
backendSim = QuantumInstance(
    BasicAer.get_backend("qasm_simulator"), shots=1024
)

# define Quantum kernel using the above feature map
kernelQuantum = QuantumKernel(feature_map=featureMap, quantum_instance=backendSim)

# Create a pipeline with standardisation
pipelineQSVM = make_pipeline(StandardScaler(), SVC(kernel=kernelQuantum.evaluate))

---

WARNING: This will take some time!!

We calculate kernel:

• When we fit the model

• When we will make prediction

---

#### pipelineQSVM.fit(X_train, y_train)

Pipeline(steps=[('standardscaler', StandardScaler()),
                ('svc',
                 SVC(kernel=<bound method QuantumKernel.evaluate of <qiskit_machine_learning.kernels.quantum_kernel.QuantumKernel object at 0x7f90fcf6e0a0>>))])

# Predict
#### y_predictQSVM = pipelineQSVM.predict(X_test)

# Accuracy
### accuracy_score(y_test,y_predictQSVM)

0.8128654970760234

---

Let us put aside the accuracy and explore the time complexity...

Both SVM and QSVM scales more-than-linearly with sample size.

The picture is based on the same dataset, bootstrapped. Numbers as of 09/2021 (situation has improved).

• Running model with 10 (!) observations is a base case (5 observations per each class – balanced sample to have proportionate number of cases per class)

• QSVM – Quadratic scaling with sample size 9× bigger dataset takes more than 15× more time!

• The run-time of 10 cases for SVM and QSVM is very different.

---

# We can explore smaller sizes
X_test[:10,:]

array([[-2.63623436e+02, -4.27685526e+01,  4.72069976e+00],
       [ 1.09240105e+03, -1.05035759e+02, -4.62868220e+00],
       [ 2.84948132e+02, -6.23920145e+01, -7.94870246e+00],
       [-4.10186841e+02,  2.94103702e+01, -2.57795592e+00],
       [-4.93647933e+02,  3.93097062e+00,  8.49856807e+00],
       [ 1.12485812e+03,  3.41292250e+01, -1.97420874e+01],
       [ 1.58612829e+03,  8.94825895e+00,  8.28452749e-01],
       [ 4.53678089e+02,  7.73999547e+01, -5.43888370e+00],
       [-2.98362656e+02,  2.26721773e+01, -1.14690119e+01],
       [-1.68343867e+02,  3.64380669e+01, -1.72813561e+01]])

y_test[:10]

array([1, 0, 0, 1, 1, 0, 0, 0, 1, 1])

---

We can run QSVM on this smaller sample but. There is no guarantee that if we choose a smaller subset, it will be balanced.

• Let us write a simple function, which samples balanced subset:

---

# Balanced sampler, size is relative
def balancedSubsampleN(yInput, xInput, sizeN=None, replace = True):

    y = pd.Series(yInput)
    
    subsample = []
    
    if sizeN is None:
        n_smp = y.value_counts().min()
    else:
        n_smp = int(sizeN)

    for label in y.value_counts().index:
        samples = y[y == label].index.values
        index_range = range(samples.shape[0])
        indexes = np.random.choice(index_range, size=n_smp, replace=replace)
        subsample += samples[indexes].tolist()
      
    # Return the balanced y and x, respectively    
    return yInput[subsample], xInput[subsample]  # ,subsampleX

ySmall_train, XSmall_train = balancedSubsampleN(y_train, X_train, sizeN=5)

XSmall_train

array([[ -79.18892836,   69.74141686,  -12.37146231],
       [-524.76915875,  -43.28719878,    5.95712441],
       [-464.33068311,    4.0443957 ,   -2.87740077],
       [-298.36265594,   22.67217734,  -11.46901194],
       [-192.91557454,   62.57301862,  -17.27433563],
       [ 828.5811985 , -180.6678687 ,  -16.36790237],
       [ 617.24296724,  -54.54308163,  -29.16534458],
       [1135.58194751,   77.07462712,  -16.04091688],
       [ 112.56045884,   -9.16055399,   -2.98236877],
       [1414.1266836 ,  110.22249213,   40.0659435 ]])

ySmall_train

array([1, 1, 1, 1, 1, 0, 0, 0, 0, 0])

---

We will use balanced samples (do not forget this!)

---

ySmall_test, XSmall_test = balancedSubsampleN(y_test, X_test, sizeN=5)

# SVM

# Create a pipeline with standardisation
pipelineSVM = make_pipeline(StandardScaler(), SVC())
pipelineSVM.fit(XSmall_train, ySmall_train)
# Predict
ySmall_predictSVM = pipelineSVM.predict(XSmall_test)
accuracy_score(ySmall_test,ySmall_predictSVM)

0.9

# dimension of problem (number of qubits)
nQubits = X.shape[1]
# number of repetitions
nReps = 1
featureMap = ZZFeatureMap(feature_dimension=nQubits, reps=nReps, entanglement="full")

# define backend (simulator)
backendSim = QuantumInstance(
    BasicAer.get_backend("qasm_simulator"), shots=1024
)

# define Quantum kernel using the above feature map
kernelQuantum = QuantumKernel(feature_map=featureMap, quantum_instance=backendSim)

# Create a pipeline with standardisation
pipelineQSVM = make_pipeline(StandardScaler(), SVC(kernel=kernelQuantum.evaluate))

pipelineQSVM.fit(XSmall_train, ySmall_train)

ySmall_predictQSVM = pipelineQSVM.predict(XSmall_test)

accuracy_score(ySmall_test,ySmall_predictQSVM)

0.5

---

Run-time is ok, but the accuracy is very bad (the method can be easily overtaken by the classical SVM).

Question: What we can do?

• We can increase sample size

  • But this leads to very long run-time.

• We can try to use ensembles

  • We can mimic what we do with Random Forests!

Remark: The above comparison of two numbers needs to be repeated to draw any conclusion.

---

---

Random Forest

• Let us assume we have a single decision tree

• General Idea: Instead of training one strong tree using the whole data set, we train number of "weaker" trees on the sub-samples and average out the result

  • The averaging out (independently constructed) trees reduces variance and thus make the estimate more accurate

  • The key element is that trees have to be independently grown

  • Constructing a tree from a previous section and then obtaining the set of sub-trees by different pruning does not help

• The tool to achieve this task is bootstrapping

---

---

Bootstrapping

• Bootstrapping: In statistics, the bootstrap means random sampling with replacement

• The usual application is to estimate the properties of an estimator (bias, variance, confidence intervals...)

• Let us illustrate the bootstrap on the simple example: Let us toss a coin and denote 1 when heads and 0 when tails. We are interested in the properties of the estimator of average value when we toss a coin $N$-times

  • $N$-times tossing a coin means that we obtain a series of $x_{1},x_{2},\dots,x_{N}$, with $x_{i}=0,1$

  • The estimator is defined as $\mu_{N}=\frac{1}{N}\sum_{i=1}^{N}x_{i}$

  • For two independent experiments ($N$ tosses of a coin) we obtain different values

  • What is its average value? What is a distribution of $\mu_{N}$ (when we repeat the experiment)?

• How to estimate the properties of the $\mu_{N}$?

---

---

Bootstrapping

• The route we follow is the bootstrapping procedure, where the random sampling with replacement is done from the empirical distribution function

  • Create bootstrapped sample: $N$-random draws from $x_{1},x_{2},x_{3},\dots,x_{N}$
  • The resulting sample may look as follows: $\tilde{X}_{a}=x_{3},x_{4},x_{1},x_{N},x_{1},\dots$
  • Calculate the estimator on the bootstrapped sample $\textrm{$\tilde{X}{a}$, denote it as $\mu{N,a}$}$
  • Repeat the procedure for $a=1,2,3,\dots$ and collect the set of $\mu_{N,1},\mu_{N,2},\mu_{N,2},\dots$
  • The statistical properties $\mu_{N}$ can be deduced from the distribution of $\mu_{N,1},\mu_{N,2},\mu_{N,3},\dots$
  • The first moment, second moment,...
  • The percentiles of the distribution $f\left(\mu_{N}\right)$ can be derived in a similar manner
  • Question: How would you construct the hypothesis about the $\mu_{N}$ being equal to $\omega$?

---

---

Bootstrapping

• The properties of an estimator estimated without any parametric assumptions

• The bootstrapping can be used for estimating properties in the linear regression

  • For an $i$-th observation, let us denote $x_{i}$ to be independent variable (multidimensional), $y_{i}$ to be dependent variable
  • Let us denote $\hat{y}_{i}$ to be an estimated value for the dependent variable using a model (regression) of interest and $\hat{e}_{i}=\hat{y_{i}}-y_{i}$ the residuals of the fit

  • The bootstrapping is then performed on the residuals

    • Fit the model for all $i$ ($i=1,\dots,I$), collect $\hat{e}_{i}$
    • Sample with replacement a set of $I$ values, denoted as $\tilde{e}_{1},\tilde{e}_{2},\tilde{e}_{3},\dots$
    • Create bootstrapped dependent variables $\tilde{y}_{i}=y_{i}+\tilde{e}_{i}$
    • Fit a new model of $x_{i}$ on\textrm{ $\tilde{y}_{i}$ and retain the variables of interest from the fit}
    • Estimate properties of the fit on the bootstrapped sample

---

---

Bootstrapping

• There is a number of extensions in the literature:

  • Gaussian process regression bootstrap
  • Wild bootstrap
  • Block bootstrap
  • Bayesian bootstrap
  • White-noise bootstrap

---

---

Bagging

• Bootstrap was used to estimate the properties of the estimator (accuracy)

• We can use it to improve the prediction itself

  • We use the example of a tree, but the procedure is general!
  • Bagging -- bootstrap aggregation

• The bootstrap can be in the Bayesian framework linked to a posteriori average

• Let us outline the framework for the bootstrapping trees:

  • Independent variable: $x_{i}$
  • Dependent variable: $y_{i}$
  • The training sample has $N$ observations, .i.e, $Z=\left(\left(x_{1},y_{1}\right),\left(x_{2},y_{2}\right),\dots,\left(x_{N},y_{N}\right)\right)$
  • The objective is a regression of $y$ on $x$. The prediction (estimate) of the dependent variable for an input $x$ is denoted as $\hat{f}\left(x\right)$

---

---

Bagging

• Let us create a $b$-th bootstrap sample $Z_{b}^{*}$ as a random sample with replacement from $Z$, with $b=1,\dots,B$
• Fit the model $\hat{f}_{b}\left(x\right)$
• The bagging estimate of the model at $x$ is defined as:

$$ \hat{f}_{bag}\left(x\right)=\frac{1}{B}\sum_{b}\hat{f}_{b}\left(x\right)\,. $$

• Let us denote $\hat{P}$ the empirical distribution function, which puts an equal probability on every observation $\left(x_{i},y_{i}\right)$

  • The true bagging estimate is $E_{\hat{P}}\hat{f}^{*}\left(x\right)$ where $Z^{*}=\left(\left(x_{1}^{*},y_{1}^{*}\right),\left(x_{2}^{*},y_{2}^{*}\right),\dots,\left(x_{N}^{*},y_{N}^{*}\right)\right)$ and each pair coming from $\hat{P}$

    • If the model $f$ is an adaptive (non-linear) function of the data, $\hat{f}_{bag}\left(x\right)$ will differ from $\hat{f}\left(x\right)$, otherwise $\hat{f}_{bag}\left(x\right)\to\hat{f}\left(x\right)$ as $B\to\infty$

---

---

Bagging and Trees

• Tree-based regression/classification is adaptive function to the data

• For every bootstrapped sample, the regression tree is grown

  • Since the data are different, the different tree is found

    • Different number of terminal nodes
    • Different features involved in growing the tree
    • Different values for splitting (when the same features are used)

• The bagged tree estimate at input $x$ is thus an average of $B$ trees grown on the $B$ independent bootstrapped samples and estimated

---

---

Bagging and Trees

• Let us follow a detailed example:

  • The underlying problem is a $K$-class classification
  • Let us denote the classifier $\hat{G}\left(x\right)$ for the $K$-class response
  • The underlying function is a $K$-dimensional indicator-vector function $\hat{f}\left(x\right)$ with a single value being equal to $1$ and $K-1$ being equal to $0$

$$ \hat{G}\left(x\right)=\arg\max_{k}\hat{f}\left(x\right) $$

• The bag estimate of the $K$-class classification tree is $\hat{f}_{bag}\left(x\right)$ is a $K$-vector $\left[r_{1}\left(x\right),r_{2}\left(x\right),\dots\right]$, where $r_{k}$ is a proportion of trees from the bag classifying the state as $k$ at input $x$ giving

$$ \hat{G}_{bag}\left(x\right)=\arg\max_{k}\hat{f}_{bag}\left(x\right) $$

---

---

Bagging and Trees

• Often we require the class-probability estimates at $x$

  • We may assign utility on each class and thus the probability matters

• Voting proportions $r_{k}\left(x\right)$ cannot be class-probabilities

• Proof by example:

  • Two-class example, where we suppose the true probability of class 1 at $x$ is $0.75$
  • Each of the bagged classifiers accurately predict $1$
  • This implies that $r_{1}\left(x\right)=1$ -- incorrect
  • The bagging thus should average the underlying probabilities, where instead of $\hat{f}\left(x\right)$ we use the proportions of individual states

    * This is usually available for every classifier
    * It also tends to produce bagged classifiers with lower variance (for small B)

---

---

Bagging -- To Overcome the Computational Time of the QSVM

• We can follow the workflow to construct random forest and create forest of QSVM

• If there is a computational improvement, the time speed up may be significant

• Remark: Different trees based on data vs randomness of individual QSVM "stumps"

• Let us illustrate the procedure in the following:

---

# dimension of problem (number of qubits)
nQubits = X.shape[1]
# number of repetitions
nReps = 2
featureMap = ZZFeatureMap(feature_dimension=nQubits, reps=nReps, entanglement="full")

# define backend (simulator)
backendSim = QuantumInstance(
    BasicAer.get_backend("qasm_simulator"), shots=1024
)

# define Quantum kernel using the above feature map
kernelQuantum = QuantumKernel(feature_map=featureMap, quantum_instance=backendSim)

# Number of Repetitions
nRep = 10
# Size of each sample per class
nSize = 10

listModels = []

# Calibrating individual "stumps"
for i in range(nRep):
    # get a sample
    ySmall_tr, XSmall_tr = balancedSubsampleN(y_train, X_train, sizeN=nSize)

    # Create a pipeline with standardisation
    pipelineQSVM = make_pipeline(StandardScaler(), SVC(kernel=kernelQuantum.evaluate))    

    pipelineQSVM.fit(XSmall_tr, ySmall_tr)
    
    listModels.append(pipelineQSVM)

# Prediction step -- using smaller sample
ySmall_ts, XSmall_ts = balancedSubsampleN(y_test, X_test, sizeN=nSize)
ySmall_ts_vec = []

# Individual accuracies
accVec = []

for i in range(nRep):
    mdl = listModels[i]
    ySmall_prd = mdl.predict(XSmall_ts)
    ySmall_ts_vec.append(ySmall_prd)
    accVec.append(accuracy_score(ySmall_ts,ySmall_prd))

print('The average accuracy of individual rounds is: %5.3f.' % np.array(accVec).mean())

# Aggregate
ySmall_ts_HardPred = np.array(ySmall_ts_vec).mean(axis = 0).round()
print('The accuracy of hard aggregate is: %5.3f.' % accuracy_score(ySmall_ts,ySmall_ts_HardPred))

The average accuracy of individual rounds is: 0.585.
The accuracy of hard aggregate is: 0.700.

---

Let us run the individual run on large sample

---

ySmall_tr, XSmall_tr = balancedSubsampleN(y_train, X_train, sizeN=nSize*nRep)

# Create a pipeline with standardisation
pipelineQSVM = make_pipeline(StandardScaler(), SVC(kernel=kernelQuantum.evaluate))  
pipelineQSVM.fit(XSmall_tr, ySmall_tr)
ySmallLong_prd = mdl.predict(XSmall_ts)
accuracy_score(ySmall_ts,ySmallLong_prd)

0.5